home *** CD-ROM | disk | FTP | other *** search
/ ...taking it to the Macs! / ...taking it to the Macs!.iso / Extras / ActiveX Mac SDK / ActiveX SDK / Control Common / string.c < prev   
Encoding:
C/C++ Source or Header  |  1996-08-28  |  9.1 KB  |  619 lines  |  [TEXT/CWIE]
  1. /*/  Metrowerks Standard Library  Version 1.2  07-May-96  /*/
  2.  
  3. /*
  4.  *    string.c
  5.  *    
  6.  *        Copyright © 1995-1996 Metrowerks, Inc.
  7.  *        All rights reserved.
  8.  *    
  9.  *    Routines
  10.  *    --------
  11.  *        strlen
  12.  *
  13.  *        strcpy
  14.  *        strcat
  15.  *        strcmp
  16.  *
  17.  *        strncpy
  18.  *        strncat
  19.  *        strncmp
  20.  *
  21.  *        strcoll
  22.  *        strxfrm
  23.  *
  24.  *        strchr
  25.  *        strrchr
  26.  *        strstr
  27.  *
  28.  *        strspn
  29.  *        strcspn
  30.  *        strpbrk
  31.  *        strtok
  32.  *
  33.  *        strerror
  34.  *    
  35.  *    Modification History
  36.  *    --------------------
  37.  *
  38.  *    24-May-95 JFH  First code release.
  39.  *    23-Jun-95 JFH  Fixed strstr's tendency to not find patterns that aren't
  40.  *                                 suffixes of the target string. Dumb mistake.
  41.  *  29-Nov-95 JFH  Tweaked strncpy, strcmp, and strncmp for efficiency.
  42.  *    08-Dec-95 JFH  Fixed bug in PPC version of strpbrk (returned p-1 instead of p).
  43.  *    08-Dec-95 JFH  Fixed bug in PPC version of strrchr (was copy of PPC version of strchr).
  44.  *  22-Jan-96 JFH  Bracketed strlen() and strcpy() by #if <condition too complex to put here>
  45.  *                                 (they are inlined in <string.h> if this condition fails).
  46.  *    29-Apr-96 JFH  Merged Win32 changes in.
  47.  *                        CTV
  48.  */
  49.  
  50. #include <errno.h>
  51. #include <stdio.h>
  52. #include <string.h>
  53.  
  54. #pragma warn_possunwant off
  55.  
  56. #if __dest_os == __Win32_os
  57.  
  58. #include <string.win32.h>
  59.  
  60. #elif !__MC68K__ || _No_String_Inlines || !defined(__cplusplus)
  61.  
  62. size_t (strlen)(const char * str)
  63. {
  64.     size_t    len = -1;
  65.     
  66. #if !__POWERPC__
  67.     
  68.     do
  69.         len++;
  70.     while (*str++);
  71.     
  72. #else
  73.     
  74.     unsigned char * p = (unsigned char *) str - 1;
  75.     
  76.     do
  77.         len++;
  78.     while (*++p);
  79.     
  80. #endif
  81.     
  82.     return(len);
  83. }
  84.  
  85. char * (strcpy)(char * dst, const char * src)
  86. {
  87. #if !__POWERPC__
  88.     
  89.     const    char * p = src;
  90.                 char * q = dst;
  91.     
  92.     while (*q++ = *p++);
  93.     
  94. #else
  95.     
  96.     const    unsigned char * p = (unsigned char *) src - 1;
  97.                 unsigned char * q = (unsigned char *) dst - 1;
  98.     
  99.     while (*++q = *++p);
  100.  
  101. #endif
  102.     
  103.     return(dst);
  104. }
  105.  
  106. #endif /* !__MC68K__ || _No_String_Inlines || !defined(__cplusplus) */
  107.  
  108. #if __dest_os != __Win32_os
  109.  
  110. char * strncpy(char * dst, const char * src, size_t n)
  111. {
  112. #if !__POWERPC__
  113.     
  114.     const    char * p = src;
  115.                 char * q = dst;
  116.     
  117.     n++;
  118.     
  119.     while (--n)
  120.         if (!(*q++ = *p++))
  121.         {
  122.             while (--n)
  123.                 *q++ = 0;
  124.             break;
  125.         }
  126.     
  127. #else
  128.     
  129.     const    unsigned char * p        = (const unsigned char *) src - 1;
  130.                 unsigned char * q        = (unsigned char *) dst - 1;
  131.                 unsigned char zero    = 0;
  132.     
  133.     n++;
  134.     
  135.     while (--n)
  136.         if (!(*++q = *++p))
  137.         {
  138.             while (--n)
  139.                 *++q = 0;
  140.             break;
  141.         }
  142.  
  143. #endif
  144.     
  145.     return(dst);
  146. }
  147.  
  148. char * strcat(char * dst, const char * src)
  149. {
  150. #if !__POWERPC__
  151.     
  152.     const    char * p = src;
  153.                 char * q = dst;
  154.     
  155.     while (*q++);
  156.     
  157.     q--;
  158.     
  159.     while (*q++ = *p++);
  160.     
  161. #else
  162.     
  163.     const    unsigned char * p = (unsigned char *) src - 1;
  164.                 unsigned char * q = (unsigned char *) dst - 1;
  165.     
  166.     while (*++q);
  167.     
  168.     q--;
  169.     
  170.     while (*++q = *++p);
  171.  
  172. #endif
  173.     
  174.     return(dst);
  175. }
  176.  
  177. char * strncat(char * dst, const char * src, size_t n)
  178. {
  179. #if !__POWERPC__
  180.     
  181.     const    char * p = src;
  182.                 char * q = dst;
  183.     
  184.     while (*q++);
  185.     
  186.     q--; n++;
  187.     
  188.     while (--n)
  189.         if (!(*q++ = *p++))
  190.         {
  191.             q--;
  192.             break;
  193.         }
  194.     
  195.     *q = 0;
  196.     
  197. #else
  198.     
  199.     const    unsigned char * p = (unsigned char *) src - 1;
  200.                 unsigned char * q = (unsigned char *) dst - 1;
  201.     
  202.     while (*++q);
  203.     
  204.     q--; n++;
  205.     
  206.     while (--n)
  207.         if (!(*++q = *++p))
  208.         {
  209.             q--;
  210.             break;
  211.         }
  212.     
  213.     *++q = 0;
  214.  
  215. #endif
  216.     
  217.     return(dst);
  218. }
  219.  
  220. int strcmp(const char * str1, const char * str2)
  221. {
  222. #if !__POWERPC__
  223.     
  224.     const    unsigned char * p1 = (unsigned char *) str1;
  225.     const    unsigned char * p2 = (unsigned char *) str2;
  226.                 unsigned char        c1, c2;
  227.     
  228.     while ((c1 = *p1++) == (c2 = *p2++))
  229.         if (!c1)
  230.             return(0);
  231.  
  232. #else
  233.     
  234.     const    unsigned char * p1 = (unsigned char *) str1 - 1;
  235.     const    unsigned char * p2 = (unsigned char *) str2 - 1;
  236.                 unsigned long        c1, c2;
  237.         
  238.     while ((c1 = *++p1) == (c2 = *++p2))
  239.         if (!c1)
  240.             return(0);
  241.  
  242. #endif
  243.     
  244.     return(c1 - c2);
  245. }
  246.  
  247. int strncmp(const char * str1, const char * str2, size_t n)
  248. {
  249. #if !__POWERPC__
  250.     
  251.     const    unsigned char * p1 = (unsigned char *) str1;
  252.     const    unsigned char * p2 = (unsigned char *) str2;
  253.                 unsigned char        c1, c2;
  254.     
  255.     n++;
  256.     
  257.     while (--n)
  258.         if ((c1 = *p1++) != (c2 = *p2++))
  259.             return(c1 - c2);
  260.         else if (!c1)
  261.             break;
  262.     
  263. #else
  264.     
  265.     const    unsigned char * p1 = (unsigned char *) str1 - 1;
  266.     const    unsigned char * p2 = (unsigned char *) str2 - 1;
  267.                 unsigned long        c1, c2;
  268.     
  269.     n++;
  270.     
  271.     while (--n)
  272.         if ((c1 = *++p1) != (c2 = *++p2))
  273.             return(c1 - c2);
  274.         else if (!c1)
  275.             break;
  276.  
  277. #endif
  278.     
  279.     return(0);
  280. }
  281.  
  282. char * strchr(const char * str, int chr)
  283. {
  284. #if !__POWERPC__
  285.  
  286.     const char * p = str;
  287.           char   c = chr;
  288.           char   ch;
  289.     
  290.     while(ch = *p++)
  291.         if (ch == c)
  292.             return((char *) (p - 1));
  293.     
  294.     return(c ? 0 : (char *) (p - 1));
  295.  
  296. #else
  297.  
  298.     const unsigned char * p = (unsigned char *) str - 1;
  299.           unsigned long   c = chr;
  300.           unsigned long   ch;
  301.     
  302.     while(ch = *++p)
  303.         if (ch == c)
  304.             return((char *) p);
  305.     
  306.     return(c ? 0 : (char *) p);
  307.  
  308. #endif
  309. }
  310.  
  311. #endif /* __dest_os != __Win32_os */
  312.  
  313. int strcoll(const char *str1, const char * str2)
  314. {
  315.     return(strcmp(str1, str2));
  316. }
  317.  
  318. size_t strxfrm(char * str1, const char * str2, size_t n)
  319. {
  320.     strncpy(str1, str2, n);
  321.     return(strlen(str2));
  322. }
  323.  
  324. char * strrchr(const char * str, int chr)
  325. {
  326. #if !__POWERPC__
  327.  
  328.     const char * p = str;
  329.     const char * q = 0;
  330.           char   c = chr;
  331.           char   ch;
  332.     
  333.     while(ch = *p++)
  334.         if (ch == c)
  335.             q = p - 1;
  336.     
  337.     if (q)
  338.         return((char *) q);
  339.     
  340.     return(c ? 0 : (char *) (p - 1));
  341.  
  342. #else
  343.  
  344.     const unsigned char * p = (unsigned char *) str - 1;
  345.     const unsigned char * q = 0;
  346.           unsigned long   c = chr;
  347.           unsigned long   ch;
  348.     
  349.     while(ch = *++p)
  350.         if (ch == c)
  351.             q = p;
  352.     
  353.     if (q)
  354.         return((char *) q);
  355.     
  356.     return(c ? 0 : (char *) p);
  357.  
  358. #endif
  359. }
  360.  
  361. typedef unsigned char char_map[32];
  362.  
  363. #define set_char_map(map, ch)     map[ch>>3] |= (1 << (ch&7))
  364. #define tst_char_map(map, ch) (map[ch>>3] &  (1 << (ch&7)))
  365.  
  366. char * strpbrk(const char * str, const char * set)
  367. {
  368.     const unsigned char *    p;
  369.           int                            c;
  370.                 char_map                map = {0};
  371.     
  372. #if !__POWERPC__
  373.     
  374.     p = (unsigned char *) set;
  375.  
  376.     while (c = *p++)
  377.         set_char_map(map, c);
  378.     
  379.     p = (unsigned char *) str;
  380.     
  381.     while (c = *p++)
  382.         if (tst_char_map(map, c))
  383.             return((char *) (p - 1));
  384.             
  385.     return(NULL);
  386.  
  387. #else
  388.     
  389.     p = (unsigned char *) set - 1;
  390.  
  391.     while (c = *++p)
  392.         set_char_map(map, c);
  393.     
  394.     p = (unsigned char *) str - 1;
  395.     
  396.     while (c = *++p)
  397.         if (tst_char_map(map, c))
  398.             return((char *) p);
  399.             
  400.     return(NULL);
  401.  
  402. #endif
  403. }
  404.  
  405. size_t strspn(const char * str, const char * set)
  406. {
  407.     const unsigned char *    p;
  408.           int                            c;
  409.                 char_map                map = {0};
  410.     
  411. #if !__POWERPC__
  412.     
  413.     p = (unsigned char *) set;
  414.  
  415.     while (c = *p++)
  416.         set_char_map(map, c);
  417.     
  418.     p = (unsigned char *) str;
  419.     
  420.     while (c = *p++)
  421.         if (!tst_char_map(map, c))
  422.             break;
  423.             
  424.     return(p - (unsigned char *) str - 1);
  425.  
  426. #else
  427.     
  428.     p = (unsigned char *) set - 1;
  429.  
  430.     while (c = *++p)
  431.         set_char_map(map, c);
  432.     
  433.     p = (unsigned char *) str - 1;
  434.     
  435.     while (c = *++p)
  436.         if (!tst_char_map(map, c))
  437.             break;
  438.             
  439.     return(p - (unsigned char *) str);
  440.  
  441. #endif
  442. }
  443.  
  444. size_t strcspn(const char * str, const char * set)
  445. {
  446.     const unsigned char *    p;
  447.           int                            c;
  448.                 char_map                map = {0};
  449.     
  450. #if !__POWERPC__
  451.     
  452.     p = (unsigned char *) set;
  453.  
  454.     while (c = *p++)
  455.         set_char_map(map, c);
  456.     
  457.     p = (unsigned char *) str;
  458.     
  459.     while (c = *p++)
  460.         if (tst_char_map(map, c))
  461.             break;
  462.             
  463.     return(p - (unsigned char *) str - 1);
  464.  
  465. #else
  466.     
  467.     p = (unsigned char *) set - 1;
  468.  
  469.     while (c = *++p)
  470.         set_char_map(map, c);
  471.     
  472.     p = (unsigned char *) str - 1;
  473.     
  474.     while (c = *++p)
  475.         if (tst_char_map(map, c))
  476.             break;
  477.             
  478.     return(p - (unsigned char *) str);
  479.  
  480. #endif
  481. }
  482.  
  483. char * strtok(char * str, const char * set)
  484. {
  485.                                 unsigned char *    p, * q;
  486.     __tls static    unsigned char *    n        = (unsigned char *) "";
  487.     __tls static    unsigned char *    s        = (unsigned char *) "";
  488.                               int                            c;
  489.                                 char_map                map    = {0};
  490.     
  491.     if (str)
  492.         s = (unsigned char *) str;
  493.     
  494. #if !__POWERPC__
  495.     
  496.     p = (unsigned char *) set;
  497.  
  498.     while (c = *p++)
  499.         set_char_map(map, c);
  500.     
  501.     p = s;
  502.     
  503.     while (c = *p++)
  504.         if (!tst_char_map(map, c))
  505.             break;
  506.     
  507.     if (!c)
  508.     {
  509.         s = n;
  510.         return(NULL);
  511.     }
  512.     
  513.     q = p - 1;
  514.     
  515.     while (c = *p++)
  516.         if (tst_char_map(map, c))
  517.             break;
  518.     
  519.     if (!c)
  520.         s = n;
  521.     else
  522.     {
  523.         s    = p;
  524.         *--p = 0;
  525.     }
  526.     
  527.     return((char *) q);
  528.  
  529. #else
  530.     
  531.     p = (unsigned char *) set - 1;
  532.  
  533.     while (c = *++p)
  534.         set_char_map(map, c);
  535.     
  536.     p = s - 1;
  537.     
  538.     while (c = *++p)
  539.         if (!tst_char_map(map, c))
  540.             break;
  541.     
  542.     if (!c)
  543.     {
  544.         s = n;
  545.         return(NULL);
  546.     }
  547.     
  548.     q = p;
  549.     
  550.     while (c = *++p)
  551.         if (tst_char_map(map, c))
  552.             break;
  553.     
  554.     if (!c)
  555.         s = n;
  556.     else
  557.     {
  558.         s  = p + 1;
  559.         *p = 0;
  560.     }
  561.     
  562.     return((char *) q);
  563.  
  564. #endif
  565. }
  566.  
  567. char * strstr(const char * str, const char * pat)
  568. {
  569. #if !__POWERPC__
  570.  
  571.     unsigned char * s1 = (unsigned char *) str;
  572.     unsigned char * p1 = (unsigned char *) pat;
  573.     unsigned char firstc, c1, c2;
  574.     
  575.     if (!(firstc = *p1++))
  576.         return((char *) s1);
  577.  
  578.     while(c1 = *s1++)
  579.         if (c1 == firstc)
  580.         {
  581.             const unsigned char * s2 = s1;
  582.             const unsigned char * p2 = p1;
  583.             
  584.             while ((c1 = *s2++) == (c2 = *p2++) && c1);
  585.             
  586.             if (!c2)
  587.                 return((char *) s1 - 1);
  588.         }
  589.     
  590.     return(NULL);
  591.  
  592. #else
  593.  
  594.     unsigned char * s1 = (unsigned char *) str-1;
  595.     unsigned char * p1 = (unsigned char *) pat-1;
  596.     unsigned long firstc, c1, c2;
  597.     
  598.     if (!(firstc = *++p1))
  599.         return((char *) s1);
  600.  
  601.     while(c1 = *++s1)
  602.         if (c1 == firstc)
  603.         {
  604.             const unsigned char * s2 = s1-1;
  605.             const unsigned char * p2 = p1-1;
  606.             
  607.             while ((c1 = *++s2) == (c2 = *++p2) && c1);
  608.             
  609.             if (!c2)
  610.                 return((char *) s1);
  611.         }
  612.     
  613.     return(NULL);
  614.  
  615. #endif
  616. }
  617.  
  618. #pragma warn_possunwant reset
  619.